# RUN: env SUPPORT_LIB=%mlir_c_runner_utils \
# RUN:   %PYTHON %s | FileCheck %s

import ctypes
import errno
import itertools
import os
import sys

from typing import List, Callable

import numpy as np

from mlir import ir
from mlir import runtime as rt

from mlir.dialects import bufferization
from mlir.dialects import builtin
from mlir.dialects import func
from mlir.dialects import sparse_tensor as st

_SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__))
sys.path.append(_SCRIPT_PATH)
from tools import sparsifier

# ===----------------------------------------------------------------------=== #


class TypeConverter:
    """Converter between NumPy types and MLIR types."""

    def __init__(self, context: ir.Context):
        # Note 1: these are numpy "scalar types" (i.e., the values of
        # np.sctypeDict) not numpy "dtypes" (i.e., the np.dtype class).
        #
        # Note 2: we must construct the MLIR types in the same context as the
        # types that'll be passed to irtype_to_sctype() or irtype_to_dtype();
        # otherwise, those methods will raise a KeyError.
        types_list = [
            (np.float64, ir.F64Type.get(context=context)),
            (np.float32, ir.F32Type.get(context=context)),
            (np.int64, ir.IntegerType.get_signless(64, context=context)),
            (np.int32, ir.IntegerType.get_signless(32, context=context)),
            (np.int16, ir.IntegerType.get_signless(16, context=context)),
            (np.int8, ir.IntegerType.get_signless(8, context=context)),
        ]
        self._sc2ir = dict(types_list)
        self._ir2sc = dict(((ir, sc) for sc, ir in types_list))

    def dtype_to_irtype(self, dtype: np.dtype) -> ir.Type:
        """Returns the MLIR equivalent of a NumPy dtype."""
        try:
            return self.sctype_to_irtype(dtype.type)
        except KeyError as e:
            raise KeyError(f"Unknown dtype: {dtype}") from e

    def sctype_to_irtype(self, sctype) -> ir.Type:
        """Returns the MLIR equivalent of a NumPy scalar type."""
        if sctype in self._sc2ir:
            return self._sc2ir[sctype]
        else:
            raise KeyError(f"Unknown sctype: {sctype}")

    def irtype_to_dtype(self, tp: ir.Type) -> np.dtype:
        """Returns the NumPy dtype equivalent of an MLIR type."""
        return np.dtype(self.irtype_to_sctype(tp))

    def irtype_to_sctype(self, tp: ir.Type):
        """Returns the NumPy scalar-type equivalent of an MLIR type."""
        if tp in self._ir2sc:
            return self._ir2sc[tp]
        else:
            raise KeyError(f"Unknown ir.Type: {tp}")

    def get_RankedTensorType_of_nparray(
        self, nparray: np.ndarray
    ) -> ir.RankedTensorType:
        """Returns the ir.RankedTensorType of a NumPy array.  Note that NumPy
        arrays can only be converted to/from dense tensors, not sparse tensors."""
        return ir.RankedTensorType.get(
            nparray.shape, self.dtype_to_irtype(nparray.dtype)
        )


# ===----------------------------------------------------------------------=== #


class StressTest:
    def __init__(self, tyconv: TypeConverter):
        self._tyconv = tyconv
        self._roundtripTp = None
        self._module = None
        self._engine = None

    def _assertEqualsRoundtripTp(self, tp: ir.RankedTensorType):
        assert self._roundtripTp is not None, "StressTest: uninitialized roundtrip type"
        if tp != self._roundtripTp:
            raise AssertionError(
                f"Type is not equal to the roundtrip type.\n"
                f"\tExpected: {self._roundtripTp}\n"
                f"\tFound:    {tp}\n"
            )

    def build(self, types: List[ir.Type]):
        """Builds the ir.Module.  The module has only the @main function,
        which will convert the input through the list of types and then back
        to the initial type.  The roundtrip type must be a dense tensor."""
        assert self._module is None, "StressTest: must not call build() repeatedly"
        self._module = ir.Module.create()
        with ir.InsertionPoint(self._module.body):
            tp0 = types.pop(0)
            self._roundtripTp = tp0
            types.append(tp0)
            funcTp = ir.FunctionType.get(inputs=[tp0], results=[tp0])
            funcOp = func.FuncOp(name="main", type=funcTp)
            funcOp.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get()
            with ir.InsertionPoint(funcOp.add_entry_block()):
                arg0 = funcOp.entry_block.arguments[0]
                self._assertEqualsRoundtripTp(arg0.type)
                v = st.ConvertOp(types.pop(0), arg0)
                for tp in types:
                    w = st.ConvertOp(tp, v)
                    # Release intermediate tensors before they fall out of scope.
                    bufferization.DeallocTensorOp(v.result)
                    v = w
                self._assertEqualsRoundtripTp(v.result.type)
                func.ReturnOp(v)
        return self

    def writeTo(self, filename):
        """Write the ir.Module to the given file.  If the file already exists,
        then raises an error.  If the filename is None, then is a no-op."""
        assert (
            self._module is not None
        ), "StressTest: must call build() before writeTo()"
        if filename is None:
            # Silent no-op, for convenience.
            return self
        if os.path.exists(filename):
            raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), filename)
        with open(filename, "w") as f:
            f.write(str(self._module))
        return self

    def compile(self, compiler):
        """Compile the ir.Module."""
        assert (
            self._module is not None
        ), "StressTest: must call build() before compile()"
        assert self._engine is None, "StressTest: must not call compile() repeatedly"
        self._engine = compiler.compile_and_jit(self._module)
        return self

    def run(self, np_arg0: np.ndarray) -> np.ndarray:
        """Runs the test on the given numpy array, and returns the resulting
        numpy array."""
        assert self._engine is not None, "StressTest: must call compile() before run()"
        self._assertEqualsRoundtripTp(
            self._tyconv.get_RankedTensorType_of_nparray(np_arg0)
        )
        np_out = np.zeros(np_arg0.shape, dtype=np_arg0.dtype)
        self._assertEqualsRoundtripTp(
            self._tyconv.get_RankedTensorType_of_nparray(np_out)
        )
        mem_arg0 = ctypes.pointer(
            ctypes.pointer(rt.get_ranked_memref_descriptor(np_arg0))
        )
        mem_out = ctypes.pointer(
            ctypes.pointer(rt.get_ranked_memref_descriptor(np_out))
        )
        self._engine.invoke("main", mem_out, mem_arg0)
        return rt.ranked_memref_to_numpy(mem_out[0])


# ===----------------------------------------------------------------------=== #


def main():
    """
    USAGE: python3 test_stress.py [raw_module.mlir [compiled_module.mlir]]

    The environment variable SUPPORT_LIB must be set to point to the
    libmlir_c_runner_utils shared library.  There are two optional
    arguments, for debugging purposes.  The first argument specifies where
    to write out the raw/generated ir.Module.  The second argument specifies
    where to write out the compiled version of that ir.Module.
    """
    support_lib = os.getenv("SUPPORT_LIB")
    assert support_lib is not None, "SUPPORT_LIB is undefined"
    if not os.path.exists(support_lib):
        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), support_lib)

    # CHECK-LABEL: TEST: test_stress
    print("\nTEST: test_stress")
    with ir.Context() as ctx, ir.Location.unknown():
        sparsification_options = f"parallelization-strategy=none "
        compiler = sparsifier.Sparsifier(
            options=sparsification_options, opt_level=0, shared_libs=[support_lib]
        )
        f64 = ir.F64Type.get()
        # Be careful about increasing this because
        #     len(types) = 1 + len(level_choices)^rank * rank! * len(bitwidths)^2
        shape = range(2, 3)
        rank = len(shape)
        # All combinations.
        levels = list(
            itertools.product(
                *itertools.repeat([st.LevelType.dense, st.LevelType.compressed], rank)
            )
        )
        # All permutations.
        orderings = list(
            map(ir.AffineMap.get_permutation, itertools.permutations(range(rank)))
        )
        bitwidths = [0]
        # The first type must be a dense tensor for numpy conversion to work.
        types = [ir.RankedTensorType.get(shape, f64)]
        for level in levels:
            for ordering in orderings:
                for pwidth in bitwidths:
                    for iwidth in bitwidths:
                        attr = st.EncodingAttr.get(
                            level, ordering, None, pwidth, iwidth
                        )
                        types.append(ir.RankedTensorType.get(shape, f64, attr))
        #
        # For exhaustiveness we should have one or more StressTest, such
        # that their paths cover all 2*n*(n-1) directed pairwise combinations
        # of the `types` set.  However, since n is already superexponential,
        # such exhaustiveness would be prohibitive for a test that runs on
        # every commit.  So for now we'll just pick one particular path that
        # at least hits all n elements of the `types` set.
        #
        tyconv = TypeConverter(ctx)
        size = 1
        for d in shape:
            size *= d
        np_arg0 = np.arange(size, dtype=tyconv.irtype_to_dtype(f64)).reshape(*shape)
        np_out = (
            StressTest(tyconv)
            .build(types)
            .writeTo(sys.argv[1] if len(sys.argv) > 1 else None)
            .compile(compiler)
            .writeTo(sys.argv[2] if len(sys.argv) > 2 else None)
            .run(np_arg0)
        )
        # CHECK: Passed
        if np.allclose(np_out, np_arg0):
            print("Passed")
        else:
            sys.exit("FAILURE")


if __name__ == "__main__":
    main()
